* (used to get the largest line heights for a fixed item width and the opposite
* while itterating over a list of children, note the new index is returned) */
static GList *
-get_largest_size_for_line_in_opposing_orientation (GtkWrapBox *box,
- GtkOrientation orientation,
- GList *cursor,
- gint line_length,
- gint item_size,
- gint extra_pixels,
- gint *min_item_size,
- gint *nat_item_size)
+get_largest_size_for_line_in_opposing_orientation (GtkWrapBox *box,
+ GtkOrientation orientation,
+ GList *cursor,
+ gint line_length,
+ GtkRequestedSize *item_sizes,
+ gint extra_pixels,
+ gint *min_item_size,
+ gint *nat_item_size)
{
GtkWrapBoxPrivate *priv = box->priv;
GList *list;
/* Distribute the extra pixels to the first children in the line
* (could be fancier and spread them out more evenly) */
- this_item_size = item_size;
+ this_item_size = item_sizes[i].minimum_size;
if (extra_pixels > 0 &&
priv->spreading == GTK_WRAP_BOX_SPREAD_EXPAND)
{
gtk_widget_size_allocate (child->widget, &child_allocation);
}
+/* fit_aligned_item_requests() helper */
+static gint
+gather_aligned_item_requests (GtkWrapBox *box,
+ GtkOrientation orientation,
+ gint line_length,
+ gint item_spacing,
+ gint n_children,
+ GtkRequestedSize *item_sizes)
+{
+ GtkWrapBoxPrivate *priv = box->priv;
+ GList *list;
+ gint i;
+ gint extra_items, natural_line_size = 0;
+
+ extra_items = n_children % line_length;
+
+ for (list = priv->children, i = 0; list; list = list->next, i++)
+ {
+ GtkWrapBoxChild *child = list->data;
+ gint child_min, child_nat;
+ gint position;
+
+ if (!gtk_widget_get_visible (child->widget))
+ continue;
+
+ if (orientation == GTK_ORIENTATION_HORIZONTAL)
+ {
+ gtk_size_request_get_width (GTK_SIZE_REQUEST (child->widget),
+ &child_min, &child_nat);
+ child_min += child->hpadding * 2;
+ child_nat += child->hpadding * 2;
+ }
+ else
+ {
+ gtk_size_request_get_height (GTK_SIZE_REQUEST (child->widget),
+ &child_min, &child_nat);
+ child_min += child->vpadding * 2;
+ child_nat += child->vpadding * 2;
+ }
+
+
+ /* Get the index and push it over for the last line when spreading to the end */
+ position = i % line_length;
+
+ if (priv->spreading == GTK_WRAP_BOX_SPREAD_END && i >= n_children - extra_items)
+ position += line_length - extra_items;
+
+ /* Round up the size of every column/row */
+ item_sizes[position].minimum_size = MAX (item_sizes[position].minimum_size, child_min);
+ item_sizes[position].natural_size = MAX (item_sizes[position].natural_size, child_nat);
+ }
+
+ for (i = 0; i < line_length; i++)
+ natural_line_size += item_sizes[i].natural_size;
+
+ natural_line_size += (line_length - 1) * item_spacing;
+
+ return natural_line_size;
+}
+
+static GtkRequestedSize *
+fit_aligned_item_requests (GtkWrapBox *box,
+ GtkOrientation orientation,
+ gint avail_size,
+ gint item_spacing,
+ gint *line_length, /* in-out */
+ gint n_children)
+{
+ GtkRequestedSize *sizes, *try_sizes;
+ gint natural_line_size, try_line_size, try_length;
+
+ sizes = g_new0 (GtkRequestedSize, *line_length);
+
+ /* get the sizes for the initial guess */
+ try_line_size = natural_line_size =
+ gather_aligned_item_requests (box, orientation, *line_length, item_spacing, n_children, sizes);
+
+ /* Try columnizing the whole thing and adding an item to the end of the line;
+ * try to fit as many columns into the available size as possible */
+ for (try_length = *line_length + 1; try_line_size < avail_size; try_length++)
+ {
+ try_sizes = g_new0 (GtkRequestedSize, try_length);
+ try_line_size = gather_aligned_item_requests (box, orientation, try_length, item_spacing,
+ n_children, try_sizes);
+
+ if (try_line_size < avail_size)
+ {
+ natural_line_size = try_line_size;
+
+ *line_length = try_length;
+
+ g_free (sizes);
+ sizes = try_sizes;
+ }
+ else
+ {
+ /* oops, this one failed; stick to the last size that fit and then return */
+ g_free (try_sizes);
+ break;
+ }
+ }
+
+ return sizes;
+}
+
typedef struct {
GArray *requested;
if (priv->mode == GTK_WRAP_ALLOCATE_ALIGNED ||
priv->mode == GTK_WRAP_ALLOCATE_HOMOGENEOUS)
{
- GtkRequestedSize *sizes = NULL;
+ GtkRequestedSize *line_sizes = NULL;
+ GtkRequestedSize *item_sizes = NULL;
GList *list;
gint min_item_size, nat_item_size;
gint line_length;
- gint item_size;
+ gint item_size = 0;
gint line_size = 0, min_fixed_line_size = 0, nat_fixed_line_size = 0;
- gint line_offset, n_children, n_lines, line_count;
- gint extra_pixels, extra_per_item, extra_extra;
+ gint line_offset, item_offset, n_children, n_lines, line_count;
+ gint extra_pixels, extra_per_item = 0, extra_extra = 0;
gint i;
get_average_item_size (box, priv->orientation, &min_item_size, &nat_item_size);
* minimum item wrap length */
line_length = MAX (min_items, line_length);
- /* Now we need the real item allocation size */
- item_size = (avail_size - (line_length - 1) * item_spacing) / line_length;
-
- /* Cut out the expand space if we're not distributing any */
- if (priv->spreading != GTK_WRAP_BOX_SPREAD_EXPAND)
- item_size = MIN (item_size, nat_item_size);
-
- /* Get the real extra pixels incase of GTK_WRAP_BOX_SPREAD_START lines */
- extra_pixels = avail_size - (line_length - 1) * item_spacing - item_size * line_length;
- extra_per_item = extra_pixels / MAX (line_length -1, 1);
- extra_extra = extra_pixels % MAX (line_length -1, 1);
-
- /* Get how many lines that wraps to */
+ /* Get how many lines we'll be needing to wrap */
n_children = get_visible_children (box);
- n_lines = n_children / line_length;
- if ((n_children % line_length) > 0)
- n_lines++;
-
- n_lines = MAX (n_lines, 1);
/* Here we just use the largest height-for-width and use that for the height
* of all lines */
if (priv->mode == GTK_WRAP_ALLOCATE_HOMOGENEOUS)
{
+ n_lines = n_children / line_length;
+ if ((n_children % line_length) > 0)
+ n_lines++;
+
+ n_lines = MAX (n_lines, 1);
+
+ /* Now we need the real item allocation size */
+ item_size = (avail_size - (line_length - 1) * item_spacing) / line_length;
+
+ /* Cut out the expand space if we're not distributing any */
+ if (priv->spreading != GTK_WRAP_BOX_SPREAD_EXPAND)
+ item_size = MIN (item_size, nat_item_size);
+
get_largest_size_for_opposing_orientation (box, priv->orientation, item_size,
&min_fixed_line_size,
&nat_fixed_line_size);
/* resolve a fixed 'line_size' */
line_size = (avail_other_size - (n_lines - 1) * line_spacing) / n_lines;
line_size = MIN (line_size, nat_fixed_line_size);
+
+ /* Get the real extra pixels incase of GTK_WRAP_BOX_SPREAD_START lines */
+ extra_pixels = avail_size - (line_length - 1) * item_spacing - item_size * line_length;
}
else /* GTK_WRAP_ALLOCATE_ALIGNED */
{
- /* spread out the available size in the opposing orientation into an array of
- * lines (and then allocate those lines naturally) */
GList *list;
gboolean first_line = TRUE;
- sizes = g_new0 (GtkRequestedSize, n_lines);
-
- /* In ALIGNED mode, all items have the same size in the box's orientation except
- * individual lines may have a different size */
+ /* Find the amount of columns that can fit aligned into the available space
+ * and collect their requests.
+ */
+ item_sizes = fit_aligned_item_requests (box, priv->orientation, avail_size,
+ item_spacing, &line_length, n_children);
+
+ /* Calculate the number of lines after determining the final line_length */
+ n_lines = n_children / line_length;
+ if ((n_children % line_length) > 0)
+ n_lines++;
+
+ n_lines = MAX (n_lines, 1);
+ line_sizes = g_new0 (GtkRequestedSize, n_lines);
+
+ /* Get the available remaining size */
+ avail_size -= (line_length - 1) * item_spacing;
+ for (i = 0; i < line_length; i++)
+ avail_size -= item_sizes[i].minimum_size;
+
+ /* Perform a natural allocation on the columnized items and get the remaining pixels */
+ extra_pixels = gtk_distribute_natural_allocation (avail_size, line_length, item_sizes);
+
+ /* Now that we have the size of each column of items find the size of each individual
+ * line based on the aligned item sizes.
+ */
for (i = 0, list = priv->children; list != NULL; i++)
{
list =
get_largest_size_for_line_in_opposing_orientation (box, priv->orientation,
list, line_length,
- item_size, extra_pixels,
- &sizes[i].minimum_size,
- &sizes[i].natural_size);
+ item_sizes, extra_pixels,
+ &line_sizes[i].minimum_size,
+ &line_sizes[i].natural_size);
/* Its possible a line is made of completely invisible children */
- if (sizes[i].natural_size > 0)
+ if (line_sizes[i].natural_size > 0)
{
if (first_line)
first_line = FALSE;
else
avail_other_size -= line_spacing;
- avail_other_size -= sizes[i].minimum_size;
+ avail_other_size -= line_sizes[i].minimum_size;
- sizes[i].data = GINT_TO_POINTER (i);
+ line_sizes[i].data = GINT_TO_POINTER (i);
}
}
/* Distribute space among lines naturally */
- avail_other_size = gtk_distribute_natural_allocation (avail_other_size, n_lines, sizes);
+ avail_other_size = gtk_distribute_natural_allocation (avail_other_size, n_lines, line_sizes);
}
- line_offset = border_width;
+ /* Calculate expand space per item (used diferently depending on spreading mode) */
+ if (priv->spreading == GTK_WRAP_BOX_SPREAD_EVEN)
+ {
+ extra_per_item = extra_pixels / MAX (line_length -1, 1);
+ extra_extra = extra_pixels % MAX (line_length -1, 1);
+ }
+ else if (priv->spreading == GTK_WRAP_BOX_SPREAD_EXPAND)
+ {
+ extra_per_item = extra_pixels / line_length;
+ extra_extra = extra_pixels % line_length;
+ }
+
+ line_offset = item_offset = border_width;
+
+ /* prepend extra space to item_offset for SPREAD_END */
+ if (priv->spreading == GTK_WRAP_BOX_SPREAD_END)
+ item_offset += extra_pixels;
for (i = 0, line_count = 0, list = priv->children; list; list = list->next)
{
GtkWrapBoxChild *child = list->data;
- gint position, this_line_size, item_offset;
+ gint position, this_line_size;
gint this_item_size;
if (!gtk_widget_get_visible (child->widget))
if (priv->mode == GTK_WRAP_ALLOCATE_HOMOGENEOUS)
line_offset += line_size + line_spacing;
else /* aligned mode */
- line_offset += sizes[line_count].minimum_size + line_spacing;
+ line_offset += line_sizes[line_count].minimum_size + line_spacing;
line_count++;
- }
- /* We could be smarter here and distribute the extra pixels more
- * evenly across the children */
- if (position < extra_pixels && priv->spreading == GTK_WRAP_BOX_SPREAD_EXPAND)
- this_item_size = item_size + 1;
- else
- this_item_size = item_size;
+ item_offset = border_width;
+
+ if (priv->spreading == GTK_WRAP_BOX_SPREAD_END)
+ {
+ item_offset += extra_pixels;
+
+ /* If we're on the last line, prepend the space for
+ * any leading items */
+ if (line_count == n_lines -1)
+ {
+ gint extra_items = n_children % line_length;
+
+ if (priv->mode == GTK_WRAP_ALLOCATE_HOMOGENEOUS)
+ {
+ item_offset += item_size * (line_length - extra_items);
+ item_offset += item_spacing * (line_length - extra_items);
+ }
+ else
+ {
+ gint j;
+
+ for (j = 0; j < (line_length - extra_items); j++)
+ {
+ item_offset += item_sizes[j].minimum_size;
+ item_offset += item_spacing;
+ }
+ }
+ }
+ }
+ }
/* Push the index along for the last line when spreading to the end */
if (priv->spreading == GTK_WRAP_BOX_SPREAD_END &&
position += line_length - extra_items;
}
- item_offset = border_width + (position * item_size) + (position * item_spacing);
+ if (priv->mode == GTK_WRAP_ALLOCATE_HOMOGENEOUS)
+ this_item_size = item_size;
+ else /* aligned mode */
+ this_item_size = item_sizes[position].minimum_size;
- if (priv->spreading == GTK_WRAP_BOX_SPREAD_EVEN)
- {
- item_offset += position * extra_per_item;
- item_offset += MIN (position, extra_extra);
- }
- else if (priv->spreading == GTK_WRAP_BOX_SPREAD_END)
- item_offset += extra_pixels;
- else if (priv->spreading == GTK_WRAP_BOX_SPREAD_EXPAND)
- item_offset += MIN (position, extra_pixels);
+ if (priv->spreading == GTK_WRAP_BOX_SPREAD_EXPAND)
+ {
+ this_item_size += extra_per_item;
+
+ /* We could be smarter here and distribute the extra pixels more
+ * evenly across the children */
+ if (position < extra_extra)
+ this_item_size++;
+ }
/* Get the allocation size for this line */
if (priv->mode == GTK_WRAP_ALLOCATE_HOMOGENEOUS)
this_line_size = line_size;
else
- this_line_size = sizes[line_count].minimum_size;
+ this_line_size = line_sizes[line_count].minimum_size;
/* Do the actual allocation */
allocate_child (box, child, item_offset, line_offset, this_item_size, this_line_size);
+ item_offset += this_item_size;
+ item_offset += item_spacing;
+
+ /* deal with extra spacing here */
+ if (priv->spreading == GTK_WRAP_BOX_SPREAD_EVEN)
+ {
+ item_offset += extra_per_item;
+
+ if (position < extra_extra)
+ item_offset++;
+ }
+
i++;
}
+
+ g_free (item_sizes);
+ g_free (line_sizes);
}
else /* GTK_WRAP_ALLOCATE_FREE */
{
gint min_item_width, nat_item_width;
gint min_items;
gint min_height, nat_height;
- gint avail_size;
+ gint avail_size, n_children;
min_items = MAX (1, priv->minimum_line_children);
{
gint min_width;
+ n_children = get_visible_children (box);
+
/* Make sure its no smaller than the minimum */
GTK_SIZE_REQUEST_GET_IFACE (widget)->get_width (widget, &min_width, NULL);
if (priv->mode == GTK_WRAP_ALLOCATE_HOMOGENEOUS)
{
gint min_item_height, nat_item_height;
- gint lines, n_children;
+ gint lines;
/* Here we just use the largest height-for-width and
* add up the size accordingly */
&min_item_height, &nat_item_height);
/* Round up how many lines we need to allocate for */
- n_children = get_visible_children (box);
lines = n_children / line_length;
if ((n_children % line_length) > 0)
lines++;
else /* GTK_WRAP_ALLOCATE_ALIGNED */
{
GList *list = priv->children;
- gint min_line_height, nat_line_height;
+ gint min_line_height, nat_line_height, i;
gboolean first_line = TRUE;
+ GtkRequestedSize *item_sizes;
+
+ /* First get the size each set of items take to span the line
+ * when aligning the items above and below after wrapping.
+ */
+ item_sizes = fit_aligned_item_requests (box, priv->orientation, avail_size,
+ priv->horizontal_spacing, &line_length, n_children);
+
+
+ /* Get the available remaining size */
+ avail_size -= (line_length - 1) * priv->horizontal_spacing;
+ for (i = 0; i < line_length; i++)
+ avail_size -= item_sizes[i].minimum_size;
+
+ extra_pixels = gtk_distribute_natural_allocation (avail_size, line_length, item_sizes);
- /* In ALIGNED mode, all items have the same size in the box's orientation except
- * individual rows may have a different size */
while (list != NULL)
{
list =
get_largest_size_for_line_in_opposing_orientation (box, GTK_ORIENTATION_HORIZONTAL,
list, line_length,
- item_size, extra_pixels,
+ item_sizes, extra_pixels,
&min_line_height, &nat_line_height);
-
/* Its possible the line only had invisible widgets */
if (nat_line_height > 0)
{
nat_height += nat_line_height;
}
}
+
+ g_free (item_sizes);
}
}
else /* GTK_WRAP_ALLOCATE_FREE */
gint min_item_height, nat_item_height;
gint min_items;
gint min_width, nat_width;
- gint avail_size;
+ gint avail_size, n_children;
min_items = MAX (1, priv->minimum_line_children);
{
gint min_height;
+ n_children = get_visible_children (box);
+
/* Make sure its no smaller than the minimum */
GTK_SIZE_REQUEST_GET_IFACE (widget)->get_height (widget, &min_height, NULL);
if (priv->mode == GTK_WRAP_ALLOCATE_HOMOGENEOUS)
{
gint min_item_width, nat_item_width;
- gint lines, n_children;
+ gint lines;
/* Here we just use the largest height-for-width and
* add up the size accordingly */
else /* GTK_WRAP_ALLOCATE_ALIGNED */
{
GList *list = priv->children;
- gint min_line_width, nat_line_width;
+ gint min_line_width, nat_line_width, i;
gboolean first_line = TRUE;
+ GtkRequestedSize *item_sizes;
+
+ /* First get the size each set of items take to span the line
+ * when aligning the items above and below after wrapping.
+ */
+ item_sizes = fit_aligned_item_requests (box, priv->orientation, avail_size,
+ priv->vertical_spacing, &line_length, n_children);
+
+ /* Get the available remaining size */
+ avail_size -= (line_length - 1) * priv->horizontal_spacing;
+ for (i = 0; i < line_length; i++)
+ avail_size -= item_sizes[i].minimum_size;
+
+ extra_pixels = gtk_distribute_natural_allocation (avail_size, line_length, item_sizes);
- /* In ALIGNED mode, all items have the same size in the box's orientation except
- * individual rows may have a different size */
while (list != NULL)
{
list =
get_largest_size_for_line_in_opposing_orientation (box, GTK_ORIENTATION_VERTICAL,
list, line_length,
- item_size, extra_pixels,
+ item_sizes, extra_pixels,
&min_line_width, &nat_line_width);
/* Its possible the last line only had invisible widgets */
nat_width += nat_line_width;
}
}
+ g_free (item_sizes);
}
}
else /* GTK_WRAP_ALLOCATE_FREE */
projects / gtk4.git / commitdiff